import re
import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import tkinter.font as tkfont
from regex_templates import TEMPLATES

class RegexTool:
    def __init__(self, root):
        self.root = root
        self.root.title("正则表达式查询工具")
        self.root.geometry("800x600")
        
        # 设置字体
        default_font = tkfont.nametofont("TkDefaultFont")
        default_font.configure(family="微软雅黑", size=10)
        self.root.option_add("*Font", default_font)
        
        # 创建主框架
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 创建控制区域
        control_frame = ttk.LabelFrame(main_frame, text="正则表达式设置", padding="10")
        control_frame.pack(fill=tk.X, pady=5)
        
        # 模板选择区域
        ttk.Label(control_frame, text="选择模板:").grid(row=0, column=0, sticky=tk.W, pady=5)
        self.template_var = tk.StringVar()
        template_combobox = ttk.Combobox(control_frame, textvariable=self.template_var, width=20)
        template_combobox['values'] = list(TEMPLATES.keys())
        template_combobox.grid(row=0, column=1, sticky=tk.W, pady=5, padx=5)
        template_combobox.bind('<<ComboboxSelected>>', self.load_template)
        
        # 模板说明
        self.template_desc_var = tk.StringVar()
        ttk.Label(control_frame, textvariable=self.template_desc_var, wraplength=400).grid(row=0, column=2, sticky=tk.W, pady=5, padx=5)
        
        # 正则表达式输入
        ttk.Label(control_frame, text="表达式:").grid(row=1, column=0, sticky=tk.W, pady=5)
        self.regex_entry = ttk.Entry(control_frame, width=60)
        self.regex_entry.grid(row=1, column=1, columnspan=2, sticky=tk.W+tk.E, pady=5, padx=5)
        
        # 选项区域
        options_frame = ttk.Frame(control_frame)
        options_frame.grid(row=2, column=0, columnspan=3, sticky=tk.W, pady=5)
        
        # 复选框
        self.ignore_case = tk.BooleanVar(value=False)
        ttk.Checkbutton(options_frame, text="忽略大小写", variable=self.ignore_case).pack(side=tk.LEFT, padx=5)
        
        self.multi_line = tk.BooleanVar(value=False)
        ttk.Checkbutton(options_frame, text="多行模式", variable=self.multi_line).pack(side=tk.LEFT, padx=5)
        
        self.dot_all = tk.BooleanVar(value=False)
        ttk.Checkbutton(options_frame, text="点号匹配所有字符", variable=self.dot_all).pack(side=tk.LEFT, padx=5)
        
        # 执行按钮
        ttk.Button(control_frame, text="执行匹配", command=self.perform_match).grid(row=3, column=2, sticky=tk.E, pady=5)
        
        # 创建文本输入区域
        input_frame = ttk.LabelFrame(main_frame, text="输入文本", padding="10")
        input_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 示例文本按钮
        ttk.Button(input_frame, text="加载示例", command=self.load_example).pack(anchor=tk.NE)
        
        self.input_text = scrolledtext.ScrolledText(input_frame, wrap=tk.WORD, width=80, height=10)
        self.input_text.pack(fill=tk.BOTH, expand=True)
        
        # 创建匹配结果区域
        result_frame = ttk.LabelFrame(main_frame, text="匹配结果", padding="10")
        result_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        # 添加结果操作按钮
        result_buttons_frame = ttk.Frame(result_frame)
        result_buttons_frame.pack(fill=tk.X)
        
        ttk.Button(result_buttons_frame, text="清空结果", command=self.clear_results).pack(side=tk.RIGHT)
        ttk.Button(result_buttons_frame, text="复制结果", command=self.copy_results).pack(side=tk.RIGHT, padx=5)
        
        self.result_text = scrolledtext.ScrolledText(result_frame, wrap=tk.WORD, width=80, height=10)
        self.result_text.pack(fill=tk.BOTH, expand=True)
        self.result_text.configure(state='disabled')
        
        # 状态栏
        self.status_var = tk.StringVar()
        self.status_var.set("准备就绪")
        status_bar = ttk.Label(self.root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def load_template(self, event=None):
        """加载所选模板"""
        template_name = self.template_var.get()
        if template_name in TEMPLATES:
            template = TEMPLATES[template_name]
            self.regex_entry.delete(0, tk.END)
            self.regex_entry.insert(0, template["pattern"])
            self.template_desc_var.set(f"{template['description']} (例如: {template['example']})")
            self.status_var.set(f"已加载模板: {template_name}")
    
    def load_example(self):
        """加载示例文本"""
        template_name = self.template_var.get()
        if template_name in TEMPLATES:
            self.input_text.delete(1.0, tk.END)
            self.input_text.insert(tk.END, TEMPLATES[template_name]["example"])
            self.status_var.set(f"已加载示例文本: {template_name}")
        else:
            messagebox.showinfo("提示", "请先选择一个模板")
    
    def clear_results(self):
        """清空结果区域"""
        self.result_text.configure(state='normal')
        self.result_text.delete(1.0, tk.END)
        self.result_text.configure(state='disabled')
        self.status_var.set("结果已清空")
    
    def copy_results(self):
        """复制结果到剪贴板"""
        result_content = self.result_text.get(1.0, tk.END)
        if result_content.strip():
            self.root.clipboard_clear()
            self.root.clipboard_append(result_content)
            self.status_var.set("结果已复制到剪贴板")
        else:
            self.status_var.set("没有结果可复制")
    
    def perform_match(self):
        # 清空结果区域
        self.result_text.configure(state='normal')
        self.result_text.delete(1.0, tk.END)
        
        # 获取输入
        pattern = self.regex_entry.get()
        text = self.input_text.get(1.0, tk.END)
        
        if not pattern:
            self.status_var.set("错误: 正则表达式不能为空")
            self.result_text.configure(state='disabled')
            return
            
        # 设置标志
        flags = 0
        if self.ignore_case.get():
            flags |= re.IGNORECASE
        if self.multi_line.get():
            flags |= re.MULTILINE
        if self.dot_all.get():
            flags |= re.DOTALL
            
        try:
            # 编译正则表达式
            regex = re.compile(pattern, flags)
            
            # 查找所有匹配
            matches = list(regex.finditer(text))
            
            if matches:
                # 显示匹配结果
                self.result_text.insert(tk.END, f"找到 {len(matches)} 个匹配:\n\n")
                
                for i, match in enumerate(matches, 1):
                    # 匹配的文本
                    matched_text = match.group(0)
                    # 开始和结束位置
                    start_pos = match.start()
                    end_pos = match.end()
                    
                    # 显示匹配信息
                    self.result_text.insert(tk.END, f"匹配 #{i}:\n")
                    self.result_text.insert(tk.END, f"位置: {start_pos}-{end_pos}\n")
                    self.result_text.insert(tk.END, f"匹配文本: \"{matched_text}\"\n")
                    
                    # 显示分组情况（如果有）
                    if match.groups():
                        self.result_text.insert(tk.END, "分组:\n")
                        for j, group in enumerate(match.groups(), 1):
                            if group is not None:
                                self.result_text.insert(tk.END, f"  组 {j}: \"{group}\"\n")
                    
                    # 分隔不同匹配
                    if i < len(matches):
                        self.result_text.insert(tk.END, "\n" + "-" * 40 + "\n\n")
                
                self.status_var.set(f"成功: 找到 {len(matches)} 个匹配")
            else:
                self.result_text.insert(tk.END, "没有找到匹配")
                self.status_var.set("完成: 没有找到匹配")
                
        except re.error as e:
            self.result_text.insert(tk.END, f"正则表达式错误: {str(e)}")
            self.status_var.set(f"错误: 无效的正则表达式 - {str(e)}")
        
        self.result_text.configure(state='disabled')


if __name__ == "__main__":
    root = tk.Tk()
    app = RegexTool(root)
    root.mainloop() 